package edu.hubu.IOStream;

import java.io.*;
import java.util.Scanner;

/*I/O应用：
 * 编写程序，分别以不同方式（即选择不同的流）实现文件拷贝。
 */
public class FileCopyDemo {
    public static void main(String[] args) throws IOException {
        //记录复制文件的开始时间
        long startTime = System.currentTimeMillis();

        //输入文件的输入链接和输出路径
        Scanner sc = new Scanner(System.in);

        //采用键盘输入路径
        System.out.println("请输入需要复制的文件的路径(需含文件名)：");
        String inputFileName = sc.nextLine();
        File inputFile = new File(inputFileName);

        System.out.println("请输入文件复制到的路径(需含文件名)：");
        String outputFileName = sc.nextLine();
        File outputFile = new File(outputFileName);


        //调用复制文件的方法
//        copyFileMethod1(inputFile, outputFile);    //复制速度第四，采用“基本字节流，一次读取一个字节”
//        copyFileMethod2(inputFile, outputFile);    //复制速度第二，采用“基本字节流，一次读取一个字节数组”
//        copyFileMethod3(inputFile, outputFile);    //复制速度第三，采用“字节缓冲流，一次读取一个字节”
        copyFileMethod4(inputFile, outputFile);    //复制速度第一，采用“字节缓冲流，一次读取一个字节数组”

        //记录复制文件的结束时间
        long endTime = System.currentTimeMillis();

        //输出复制文件所进行的时间
        System.out.println("该文件的复制共用时：" + (endTime - startTime) + "毫秒！");

    }

    //基本字节流，一次读取一个字节
    private static void copyFileMethod1(File inputFile, File outputFile) throws IOException {
        //创建字节的输入流和输出流对象
        FileInputStream fis = new FileInputStream(inputFile);
        FileOutputStream fos = new FileOutputStream(outputFile);

        //基本字节流，一次读取一个字节
        int by;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }


        //关闭字节流
        fos.close();
        fis.close();
    }

    //基本字节流，一次读取一个字节数组
    private static void copyFileMethod2(File inputFile, File outputFile) throws IOException {
        //创建字节的输入流和输出流对象
        FileInputStream fis = new FileInputStream(inputFile);
        FileOutputStream fos = new FileOutputStream(outputFile);

        //基本字节流，一次读取一个字节数组
        byte[] bytes = new byte[1024];
        int len;
        while ((len = fis.read(bytes)) != -1) {
            fos.write(bytes, 0, len);
        }

        //关闭字节流
        fos.close();
        fis.close();
    }

    //字节缓冲流，一次读取一个字节
    private static void copyFileMethod3(File inputFile, File outputFile) throws IOException {
        //创建字节的输入流和输出流对象
        FileInputStream fis = new FileInputStream(inputFile);
        FileOutputStream fos = new FileOutputStream(outputFile);

        //字节缓冲流，一次读取一个字节
        //创建字节缓冲流的输入和输出对象
        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //读取和写入数据
        int by;
        while ((by = bis.read()) != -1) {
            bos.write(by);
        }
        //关闭字节缓冲流
        bos.close();
        bis.close();

        //关闭字节流
        fos.close();
        fis.close();
    }

    //字节缓冲流，一次读取一个字节数组
    private static void copyFileMethod4(File inputFile, File outputFile) throws IOException {
        //创建字节的输入流和输出流对象
        FileInputStream fis = new FileInputStream(inputFile);
        FileOutputStream fos = new FileOutputStream(outputFile);

        //字节缓冲流，一次读取一个字节数组
        //创建字节缓冲流的输入和输出对象
        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //读取和写入数据
        byte[] bytes = new byte[1024];
        int len;
        while ((len = bis.read(bytes)) != -1) {
            bos.write(bytes, 0, len);
        }
        //关闭字节缓冲流
        bos.close();
        bis.close();

        //关闭字节流
        fos.close();
        fis.close();
    }
}
